# -*- coding: utf-8 -*-
"""
历史数据相关API接口模块

包含历史数据查询、删除、清理、统计等功能接口
"""
from datetime import datetime

from flask import Blueprint, jsonify, request

from util.validation_result import get_all_validation_results, get_validation_result, \
    get_validation_results_by_time_range, get_cache_stats, delete_validation_result, cleanup_old_results

# 创建蓝图
历史数据接口蓝图 = Blueprint('历史数据接口', __name__, url_prefix='/api/history')


def 初始化历史数据接口(执行总结字典, 执行总结锁, 日志记录器, 获取用户缓存):
    """
    初始化历史数据接口，注入依赖
    """
    global _执行总结字典, _执行总结锁, _日志记录器, _获取用户缓存

    _执行总结字典 = 执行总结字典
    _执行总结锁 = 执行总结锁
    _日志记录器 = 日志记录器
    _获取用户缓存 = 获取用户缓存


@历史数据接口蓝图.route('/获取推送结果/<document_number>', methods=['GET'])
def 获取推送结果接口(document_number: str):
    """
    获取推送的校验结果接口

    参数:
        document_number: URL路径中的单据编号

    功能:
        返回指定单据的推送校验结果

    返回:
        校验结果的JSON响应，如果不存在则返回404错误
    """
    try:
        用户名 = request.args.get('username')

        cached_result = get_validation_result(用户名, document_number)
        if cached_result:
            # 转换数据字段名以匹配前端期望
            converted_result = {
                "单据号": cached_result.get("code", ""),
                "推送时间": cached_result.get("push_time", ""),
                "校验结果": {
                    "all_passed": cached_result.get("val_result", False)
                },
                "详细错误信息": cached_result.get("error_msg", []),
                "创建时间": cached_result.get("created_time", ""),
                "更新时间": cached_result.get("updated_time", ""),
                "用户ID": cached_result.get("user_id", ""),
                "ID": cached_result.get("id", "")
            }
            return jsonify({
                "状态": "成功",
                "数据": converted_result,
                "时间戳": datetime.now().isoformat()
            })
        else:
            return jsonify({"错误": "未找到该单据的校验结果"}), 404

    except Exception as 异常:
        _日志记录器.error(f"获取推送结果失败: {异常}")
        return jsonify({"错误": f"获取推送结果失败: {str(异常)}"}), 500


@历史数据接口蓝图.route('/获取所有推送结果', methods=['GET'])
def 获取所有推送结果接口():
    """
    获取所有推送的校验结果接口（合并内存和数据库数据）

    功能:
        返回所有已推送的校验结果列表，合并内存缓存和MYSQL数据库中的数据

    返回:
        包含所有校验结果的JSON响应
    """
    try:
        用户名 = request.args.get('username')

        # 从数据库获取结果
        缓存结果列表 = get_all_validation_results(用户名)

        # 转换为前端期望的结构，并按“单据号_推送时间”去重
        已见键 = set()
        转换后的结果 = []
        for result in 缓存结果列表:
            converted = {
                "单据号": result.get("code", ""),
                "推送时间": result.get("push_time", ""),
                "校验结果": {
                    "all_passed": result.get("val_result", False)
                },
                "详细错误信息": result.get("error_msg", []),
                "创建时间": result.get("created_time", ""),
                "更新时间": result.get("updated_time", ""),
                "用户ID": result.get("user_id", ""),
                "ID": result.get("id", "")
            }
            key = f"{converted['单据号']}_{converted['推送时间']}"
            if converted['单据号'] and key not in 已见键:
                已见键.add(key)
                转换后的结果.append(converted)

        # 按推送时间倒序
        转换后的结果.sort(key=lambda x: x.get('推送时间', ''), reverse=True)

        return jsonify({
            "状态": "成功",
            "数据": 转换后的结果,
            "总数量": len(转换后的结果),
            "时间戳": datetime.now().isoformat()
        })

    except Exception as 异常:
        _日志记录器.error(f"获取所有推送结果失败: {异常}")
        return jsonify({"错误": f"获取所有推送结果失败: {str(异常)}"}), 500


@历史数据接口蓝图.route('/查询', methods=['GET'])
def 查询历史数据():
    """查询历史校验数据"""
    try:
        page = int(request.args.get('page', 1))
        limit = int(request.args.get('limit', 20))
        document_number = request.args.get('document_number', '')
        start_time = request.args.get('start_time', '')
        end_time = request.args.get('end_time', '')
        用户名 = request.args.get('username')

        offset = (page - 1) * limit

        if document_number:
            result = get_validation_result(用户名, document_number)
            if result:
                # 转换数据字段名以匹配前端期望
                converted_result = {
                    "单据号": result.get("code", ""),
                    "推送时间": result.get("push_time", ""),
                    "校验结果": {
                        "all_passed": result.get("val_result", False)
                    },
                    "详细错误信息": result.get("error_msg", []),
                    "创建时间": result.get("created_time", ""),
                    "更新时间": result.get("updated_time", ""),
                    "用户ID": result.get("user_id", ""),
                    "ID": result.get("id", "")
                }
                return jsonify({
                    "success": True,
                    "data": [converted_result],
                    "total": 1,
                    "page": page,
                    "limit": limit,
                    "用户名": 用户名
                })
            else:
                return jsonify({
                    "success": True,
                    "data": [],
                    "total": 0,
                    "page": page,
                    "limit": limit,
                    "用户名": 用户名
                })
        elif start_time and end_time:
            results = get_validation_results_by_time_range(用户名, start_time, end_time)
            total = len(results)
            paginated_results = results[offset:offset + limit]

            # 转换数据字段名以匹配前端期望
            converted_results = []
            for result in results:
                converted_result = {
                    "单据号": result.get("code", ""),
                    "推送时间": result.get("push_time", ""),
                    "校验结果": {
                        "all_passed": result.get("val_result", False)
                    },
                    "详细错误信息": result.get("error_msg", []),
                    "创建时间": result.get("created_time", ""),
                    "更新时间": result.get("updated_time", ""),
                    "用户ID": result.get("user_id", ""),
                    "ID": result.get("id", "")
                }
                converted_results.append(converted_result)
            
            return jsonify({
                "success": True,
                "data": converted_results,
                "total": total,
                "page": page,
                "limit": limit,
            })
        else:
            results = get_all_validation_results(用户名, limit=limit, offset=offset)
            stats = get_cache_stats(用户名)
            total = stats.get('total_records', 0)

            # 转换数据字段名以匹配前端期望
            converted_results = []
            for result in results:
                converted_result = {
                    "单据号": result.get("code", ""),
                    "推送时间": result.get("push_time", ""),
                    "校验结果": {
                        "all_passed": result.get("val_result", False)
                    },
                    "详细错误信息": result.get("error_msg", []),
                    "创建时间": result.get("created_time", ""),
                    "更新时间": result.get("updated_time", ""),
                    "用户ID": result.get("user_id", ""),
                    "ID": result.get("id", "")
                }
                converted_results.append(converted_result)
            
            return jsonify({
                "success": True,
                "data": converted_results,
                "total": total,
                "page": page,
                "limit": limit,
                "用户名": 用户名
            })

    except Exception as e:
        _日志记录器.error(f"查询历史数据失败: {str(e)}")
        return jsonify({
            "success": False,
            "message": f"查询失败: {str(e)}"
        }), 500


@历史数据接口蓝图.route('/删除/<document_number>', methods=['DELETE'])
def 删除历史数据(document_number):
    """删除指定单据的历史数据"""
    try:
        push_time = request.args.get('push_time')
        用户名 = request.args.get('username')

        success = delete_validation_result(用户名, document_number, push_time)
        if success:
            _日志记录器.info(f"成功删除历史数据: {document_number}")
            return jsonify({
                "success": True,
                "message": f"成功删除单据 {document_number} 的历史数据"
            })
        else:
            return jsonify({
                "success": False,
                "message": f"未找到单据 {document_number} 的历史数据"
            }), 404

    except Exception as e:
        _日志记录器.error(f"删除历史数据失败: {str(e)}")
        return jsonify({
            "success": False,
            "message": f"删除失败: {str(e)}"
        }), 500


@历史数据接口蓝图.route('/批量删除', methods=['POST'])
def 批量删除历史数据():
    """批量删除历史数据"""
    try:
        data = request.get_json() or {}
        items = data.get('items', [])
        用户名 = data.get('username') or request.args.get('username')

        成功计数 = 0
        失败计数 = 0
        for item in items:
            doc = item.get('document_number') or item.get('单据号')
            ptime = item.get('push_time') or item.get('推送时间')
            if doc:
                if delete_validation_result(用户名, doc, ptime):
                    成功计数 += 1
                else:
                    失败计数 += 1

        return jsonify({
            "success": True,
            "message": f"批量删除历史数据完成: 成功{成功计数}条，失败{失败计数}条",
            "deleted": 成功计数,
            "failed": 失败计数
        })

    except Exception as e:
        _日志记录器.error(f"批量删除历史数据失败: {str(e)}")
        return jsonify({
            "success": False,
            "message": f"批量删除失败: {str(e)}"
        }), 500


@历史数据接口蓝图.route('/清理', methods=['POST'])
def 清理历史数据():
    """清理过期的历史数据"""
    try:
        data = request.get_json() or {}
        days = int(data.get('days', 30))
        用户名 = data.get('username') or request.args.get('username')

        affected = cleanup_old_results(用户名, days=days)
        return jsonify({
            "success": True,
            "message": f"清理完成: 共清理 {affected} 条记录"
        })

    except Exception as e:
        _日志记录器.error(f"清理历史数据失败: {str(e)}")
        return jsonify({
            "success": False,
            "message": f"清理失败: {str(e)}"
        }), 500


@历史数据接口蓝图.route('/统计', methods=['GET'])
def 获取历史数据统计():
    """获取历史数据统计信息"""
    try:
        用户名 = request.args.get('username')

        stats = get_cache_stats(用户名)
        return jsonify({
            "success": True,
            "data": stats,
            "用户名": 用户名
        })

    except Exception as e:
        _日志记录器.error(f"获取历史数据统计失败: {str(e)}")
        return jsonify({
            "success": False,
            "message": f"统计获取失败: {str(e)}"
        }), 500
